home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / Cpp4VB / WINTLB / KERNEL.ODL < prev    next >
Text File  |  1996-07-24  |  50KB  |  1,491 lines
  1.  
  2. //@B Kernel
  3. [
  4. uuid(54674042-3A82-101B-8181-00AA003743D3),
  5. helpstring("Windows Kernel Functions"),
  6. #ifdef WIN32
  7. dllname("KERNEL32.DLL")
  8. #else
  9. dllname("KRNL386.EXE")
  10. #endif
  11. ]
  12. module Kernel {
  13. //@E Kernel
  14.  
  15.     // ****** System Information ********
  16.  
  17.     [
  18.     usesgetlasterror,
  19.     entry("GetVersion"),
  20.     helpstring("Gets version numbers of Windows and MS-DOS"),
  21.     ]
  22.     DWORD WINAPI GetVersion();
  23.  
  24.     /* Not implemented
  25.     BOOL WINAPI GetVersionExA(
  26.         LPOSVERSIONINFOA lpVersionInformation
  27.         );
  28.  
  29.     const int VER_PLATFORM_WIN32s        = 0;
  30.     const int VER_PLATFORM_WIN32_WINDOWS = 1;
  31.     const int VER_PLATFORM_WIN32_NT      = 2;
  32.  
  33.     typedef struct _OSVERSIONINFOA {
  34.         DWORD dwOSVersionInfoSize;
  35.         DWORD dwMajorVersion;
  36.         DWORD dwMinorVersion;
  37.         DWORD dwBuildNumber;
  38.         DWORD dwPlatformId;
  39.         CHAR   szCSDVersion[ 128 ];       // Maintenance string for PSS usage
  40.     } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
  41.  
  42.     typedef OSVERSIONINFOA OSVERSIONINFO;
  43.     typedef POSVERSIONINFOA POSVERSIONINFO;
  44.     typedef LPOSVERSIONINFOA LPOSVERSIONINFO;
  45.     */
  46.  
  47.     #ifndef WIN32
  48.     [
  49.     usesgetlasterror,
  50.     entry("GetFreeSpace"),
  51.     helpstring("Gets bytes of global heap memory available"),
  52.     ]
  53.     DWORD WINAPI GetFreeSpace([in] UINT fuFlags);
  54.     #endif
  55.  
  56.     // Win32 macro
  57.     //define GetFreeSpace(w)                (0x100000L)
  58.  
  59.     /* Omitted
  60.     GetCurrentPDB
  61.     */
  62.  
  63. //@B GetWindowsDirectory
  64.     [
  65.     #ifdef WIN32
  66.     usesgetlasterror,
  67.     entry("GetWindowsDirectoryA"),
  68.     #else
  69.     entry("GetWindowsDirectory"),
  70.     #endif
  71.     helpstring("Gets Windows directory"),
  72.     ]
  73.     UINT WINAPI GetWindowsDirectory([in, out] LPSTR lpszSysPath,
  74.                                     [in] UINT cbSysPath);
  75. //@E GetWindowsDirectory
  76.  
  77.     [
  78.     #ifdef WIN32
  79.     usesgetlasterror,
  80.     entry("GetSystemDirectoryA"),
  81.     #else
  82.     entry("GetSystemDirectory"),
  83.     #endif
  84.     helpstring("Gets Windows System directory"),
  85.     ]
  86.     UINT WINAPI GetSystemDirectory([in, out] LPSTR lpszSysPath,
  87.                                    [in] UINT cbSysPath);
  88.  
  89.     #ifndef WIN32
  90.     [
  91.     usesgetlasterror,
  92.     entry("GetWinFlags"),
  93.     helpstring("Gets system and memory configuration flags"),
  94.     ]
  95.     DWORD   WINAPI GetWinFlags(VOID);
  96.     #endif
  97.  
  98.     /* Omitted
  99.     LPSTR   WINAPI GetDOSEnvironment(void);
  100.     DWORD   WINAPI GetCurrentTime(void);
  101.     DWORD   WINAPI GetTimerResolution(void);
  102.     void    WINAPI LogError(UINT err, void FAR* lpInfo);
  103.     void    WINAPI LogParamError(UINT err, FARPROC lpfn, void FAR* param);
  104.     BOOL    WINAPI GetWinDebugInfo(WINDEBUGINFO FAR* lpwdi, UINT flags);
  105.     BOOL    WINAPI SetWinDebugInfo(WINDEBUGINFO FAR* lpwdi);
  106.     void    FAR _cdecl DebugOutput(UINT flags, LPCSTR lpsz, ...);
  107.     void    WINAPI FatalExit(int);
  108.     void    WINAPI FatalAppExit(UINT, LPCSTR);
  109.     */
  110.  
  111.     #ifdef WIN32
  112.     [
  113.     usesgetlasterror,
  114.     entry("GetTickCount"),
  115.     helpstring("Returns milliseconds since Windows was started"),
  116.     ]
  117.     DWORD   WINAPI GetTickCount(void);
  118.     #endif
  119.  
  120.     [
  121.     usesgetlasterror,
  122.     entry("DebugBreak"),
  123.     helpstring("Break into a debugger"),
  124.     ]
  125.     void    WINAPI DebugBreak();
  126.  
  127.     [
  128.     #ifdef WIN32
  129.     usesgetlasterror,
  130.     entry("OutputDebugStringA"),
  131.     #else
  132.     entry("OutputDebugString"),
  133.     #endif
  134.     helpstring("Send string to the debugging terminal"),
  135.     ]
  136.     void    WINAPI OutputDebugString([in] LPCSTR lpszOutputString);
  137.  
  138.     /* Omitted
  139.     // SetErrorMode() constants
  140.     const UINT SEM_FAILCRITICALERRORS     = 0x0001;
  141.     const UINT SEM_NOGPFAULTERRORBOX      = 0x0002;
  142.     const UINT SEM_NOALIGNMENTFAULTEXCEPT = 0x0004;  // Win32 only
  143.     const UINT SEM_NOOPENFILEERRORBOX     = 0x8000;
  144.  
  145.     UINT WINAPI SetErrorMode(
  146.         UINT uMode
  147.         );
  148.  
  149.     */
  150.  
  151.     // ****** Module Management *******
  152.  
  153.     /* Omitted
  154.     HINSTANCE   WINAPI LoadModule(LPCSTR, LPVOID);
  155.     */
  156.  
  157.     #ifndef WIN32
  158.     [
  159.     usesgetlasterror,
  160.     entry("FreeModule"),
  161.     helpstring("Free a running module"),
  162.     ]
  163.     BOOL        WINAPI FreeModule([in] HINSTANCE hInst);
  164.     #endif
  165.  
  166.     [
  167.     #ifdef WIN32
  168.     usesgetlasterror,
  169.     entry("LoadLibraryA"),
  170.     #else
  171.     entry("LoadLibrary"),
  172.     #endif
  173.     helpstring("Load a DLL"),
  174.     ]
  175.     HINSTANCE   WINAPI LoadLibrary([in] LPCSTR lpszLibFileName);
  176.  
  177.     [
  178.     usesgetlasterror,
  179.     entry("FreeLibrary"),
  180.     helpstring("Free a DLL"),
  181.     ]
  182.     void        WINAPI FreeLibrary([in] HINSTANCE hInst);
  183.  
  184.     /* Not implemented
  185.     HINSTANCE WINAPI LoadLibraryExA(
  186.         LPCSTR lpLibFileName,
  187.         HANDLE hFile,
  188.         DWORD dwFlags
  189.         );
  190.  
  191.     const DWORD DONT_RESOLVE_DLL_REFERENCES = 0x00000001;
  192.     const DWORD LOAD_LIBRARY_AS_DATAFILE    = 0x00000002;
  193.  
  194.     VOID WINAPI FreeLibraryAndExitThread(
  195.         HMODULE hLibModule,
  196.         DWORD dwExitCode
  197.         );
  198.  
  199.     BOOL WINAPI DisableThreadLibraryCalls(
  200.         HMODULE hLibModule
  201.         );
  202.     */
  203.  
  204.     [
  205.     usesgetlasterror,
  206.     entry("WinExec"),
  207.     helpstring("Run an application"),
  208.     ]
  209.     UINT    WINAPI WinExec([in] LPCSTR lpszCmdLine, [in] UINT fuCmdShow);
  210.  
  211.     #ifdef WIN32
  212.  
  213.     [
  214.     usesgetlasterror,
  215.     entry("GetBinaryTypeA"),
  216.     helpstring("Determine whether an application is executable, and if so, on what platform"),
  217.     ]
  218.     BOOL WINAPI GetBinaryType([in] LPCSTR lpApplicationName,
  219.                               [in,out] DWORD * lpBinaryType);
  220.  
  221.     [
  222.     usesgetlasterror,
  223.     entry("GetShortPathNameA"),
  224.     helpstring("Gets the short path form of a specified input path"),
  225.     ]
  226.     DWORD WINAPI GetShortPathName([in] LPCSTR lpszLongPath,
  227.                                   [in, out] LPSTR lpszShortPath,
  228.                                   [in] DWORD cchBuffer);
  229.  
  230.  
  231.     /* Most of process functions not implemented
  232.     BOOL WINAPI GetProcessAffinityMask(HANDLE hProcess,
  233.                                        LPDWORD lpProcessAffinityMask,
  234.                                        LPDWORD lpSystemAffinityMask);
  235.     BOOL WINAPI GetProcessTimes(HANDLE hProcess,
  236.                                 LPFILETIME lpCreationTime,
  237.                                 LPFILETIME lpExitTime,
  238.                                 LPFILETIME lpKernelTime,
  239.                                 LPFILETIME lpUserTime);
  240.     BOOL WINAPI GetProcessWorkingSetSize(HANDLE hProcess,
  241.                                          LPDWORD lpMinimumWorkingSetSize,
  242.                                          LPDWORD lpMaximumWorkingSetSize);
  243.     BOOL WINAPI SetProcessWorkingSetSize(HANDLE hProcess,
  244.                                          DWORD  dwMinimumWorkingSetSize,
  245.                                          DWORD  dwMaximumWorkingSetSize);
  246.     BOOL WINAPI SetProcessShutdownParameters(DWORD dwLevel, DWORD dwFlags);
  247.     BOOL WINAPI GetProcessShutdownParameters(LPDWORD lpdwLevel, LPDWORD lpdwFlags);
  248.     VOID WINAPI GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo);
  249.     LPSTR WINAPI GetCommandLineA(VOID);
  250.  
  251.     [
  252.     usesgetlasterror,
  253.     entry("CreateProcessA"),
  254.     helpstring("Creates a new process and executes a specified executable file"),
  255.     ]
  256.     BOOL WINAPI CreateProcessA([in] LPCSTR lpApplicationName,
  257.                                [in] LPSTR lpCommandLine,
  258.                                [in] LPSECURITY_ATTRIBUTES lpProcessAttributes,
  259.                                [in] LPSECURITY_ATTRIBUTES lpThreadAttributes,
  260.                                [in] BOOL bInheritHandles,
  261.                                [in] DWORD dwCreationFlags,
  262.                                [in] LPVOID lpEnvironment,
  263.                                [in] LPCSTR lpCurrentDirectory,
  264.                                [in] LPSTARTUPINFOA lpStartupInfo,
  265.                                [in] LPPROCESS_INFORMATION lpProcessInformation);
  266.     */
  267.  
  268.     [
  269.     usesgetlasterror,
  270.     entry("OpenProcess"),
  271.     helpstring("Given a process ID number, returns handle of existing process"),
  272.     ]
  273.     HANDLE WINAPI OpenProcess([in] DWORD dwDesiredAccess,
  274.                               [in] BOOL bInheritHandle,
  275.                               [in] DWORD dwProcessId);
  276.  
  277.     [
  278.     usesgetlasterror,
  279.     entry("GetCurrentProcess"),
  280.     helpstring("Gets the process handle of the current process"),
  281.     ]
  282.     HANDLE WINAPI GetCurrentProcess(VOID);
  283.  
  284.     [
  285.     usesgetlasterror,
  286.     entry("GetCurrentProcessId"),
  287.     helpstring("Gets the process ID number of the current process"),
  288.     ]
  289.     DWORD WINAPI GetCurrentProcessId(VOID);
  290.  
  291.     [
  292.     usesgetlasterror,
  293.     entry("GetExitCodeProcess"),
  294.     helpstring("Gets the termination status of a given process"),
  295.     ]
  296.     BOOL WINAPI GetExitCodeProcess([in] HANDLE hProcess,
  297.                                    [out] DWORD FAR * lpExitCode);
  298.  
  299.     /*
  300.     VOID WINAPI ExitProcess(UINT uExitCode);
  301.     BOOL WINAPI TerminateProcess(HANDLE hProcess, UINT uExitCode);
  302.     VOID WINAPI FatalExit(int ExitCode);
  303.  
  304.     const DWORD STARTF_USESHOWWINDOW        = 0x00000001;
  305.     const DWORD STARTF_USESIZE              = 0x00000002;
  306.     const DWORD STARTF_USEPOSITION          = 0x00000004;
  307.     const DWORD STARTF_USECOUNTCHARS        = 0x00000008;
  308.     const DWORD STARTF_USEFILLATTRIBUTE     = 0x00000010;
  309.     const DWORD STARTF_RUNFULLSCREEN        = 0x00000020;  // ignored for non-x86 platforms
  310.     const DWORD STARTF_FORCEONFEEDBACK      = 0x00000040;
  311.     const DWORD STARTF_FORCEOFFFEEDBACK     = 0x00000080;
  312.     const DWORD STARTF_USESTDHANDLES        = 0x00000100;
  313.  
  314.     typedef struct _STARTUPINFOA {
  315.         DWORD   cb;
  316.         LPSTR   lpReserved;
  317.         LPSTR   lpDesktop;
  318.         LPSTR   lpTitle;
  319.         DWORD   dwX;
  320.         DWORD   dwY;
  321.         DWORD   dwXSize;
  322.         DWORD   dwYSize;
  323.         DWORD   dwXCountChars;
  324.         DWORD   dwYCountChars;
  325.         DWORD   dwFillAttribute;
  326.         DWORD   dwFlags;
  327.         WORD    wShowWindow;
  328.         WORD    cbReserved2;
  329.         LPBYTE  lpReserved2;
  330.         HANDLE  hStdInput;
  331.         HANDLE  hStdOutput;
  332.         HANDLE  hStdError;
  333.     } STARTUPINFOA, *LPSTARTUPINFOA;
  334.     */
  335.  
  336.  
  337.     /* Exceptions not implemented
  338.     VOID WINAPI RaiseException(
  339.         DWORD dwExceptionCode,
  340.         DWORD dwExceptionFlags,
  341.         DWORD nNumberOfArguments,
  342.         CONST DWORD *lpArguments
  343.         );
  344.  
  345.     LONG WINAPI UnhandledExceptionFilter(
  346.         struct _EXCEPTION_POINTERS *ExceptionInfo
  347.         );
  348.  
  349.     LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter(
  350.         LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
  351.         );
  352.     */
  353.     #endif  // WIN32
  354.  
  355.  
  356.     [
  357.     #ifdef WIN32
  358.     usesgetlasterror,
  359.     entry("GetModuleHandleA"),
  360.     #else
  361.     entry("GetModuleHandle"),
  362.     #endif
  363.     helpstring("Get the handle of a module from its name"),
  364.     ]
  365.     HMODULE WINAPI GetModuleHandle([in] LPCSTR lpszModuleName);
  366.  
  367.     #ifndef WIN32
  368.     [
  369.     usesgetlasterror,
  370.     entry("GetModuleUsage"),
  371.     helpstring("Get the reference count of a module from its handle"),
  372.     ]
  373.     int     WINAPI GetModuleUsage([in] HINSTANCE hInst);
  374.     #endif
  375.  
  376.     [
  377.     #ifdef WIN32
  378.     usesgetlasterror,
  379.     entry("GetModuleFileNameA"),
  380.     #else
  381.     entry("GetModuleFileName"),
  382.     #endif
  383.     helpstring("Get full path name of a module from its handle"),
  384.     ]
  385.     int     WINAPI GetModuleFileName(
  386.                     [in] HINSTANCE hInst, [out] LPSTR lpszFileName,
  387.                     [in] int cbFileName);
  388.  
  389.     /* Omitted
  390.     FARPROC WINAPI GetProcAddress(HINSTANCE, LPCSTR);
  391.     int     WINAPI GetInstanceData(HINSTANCE, BYTE*, int);
  392.     HGLOBAL WINAPI GetCodeHandle(FARPROC);
  393.     void    WINAPI GetCodeInfo(FARPROC lpProc, SEGINFO FAR* lpSegInfo);
  394.     FARPROC WINAPI MakeProcInstance(FARPROC, HINSTANCE);
  395.     void    WINAPI FreeProcInstance(FARPROC);
  396.     LONG    WINAPI SetSwapAreaSize(UINT);
  397.     void    WINAPI SwapRecording(UINT);
  398.     void    WINAPI ValidateCodeSegments(void);
  399.  
  400.     UINT    WINAPI GetNumTasks(void);
  401.     BOOL    WINAPI IsTask(HTASK);
  402.     */
  403.  
  404.     [
  405.     usesgetlasterror,
  406.     entry("GetCurrentTask"),
  407.     helpstring("Get the current process (task)"),
  408.     ]
  409.     HTASK   WINAPI GetCurrentTask(void);
  410.  
  411.     /* Omitted
  412.     void    WINAPI Yield(void);
  413.     void    WINAPI DirectedYield(HTASK);
  414.     */
  415.  
  416.     // ****** Global memory management ******
  417.  
  418.     [
  419.     usesgetlasterror,
  420.     entry("GlobalAlloc"),
  421.     helpstring("Allocate global memory"),
  422.     ]
  423.     HGLOBAL WINAPI GlobalAlloc([in] UINT fuAlloc, [in] DWORD cbAlloc);
  424.  
  425.     [
  426.     usesgetlasterror,
  427.     entry("GlobalReAlloc"),
  428.     helpstring("Resize global memory block"),
  429.     ]
  430.     HGLOBAL WINAPI GlobalReAlloc(
  431.             [in] HGLOBAL hglb, [in] DWORD cbNewSize, [in] UINT fuAlloc);
  432.  
  433.     [
  434.     usesgetlasterror,
  435.     entry("GlobalFree"),
  436.     helpstring("Free global memory block"),
  437.     ]
  438.     HGLOBAL WINAPI GlobalFree([in] HGLOBAL hglb);
  439.  
  440.     [
  441.     usesgetlasterror,
  442.     entry("GlobalLock"),
  443.     helpstring("Locks global memory block and returns pointer to it"),
  444.     ]
  445.     LPVOID WINAPI GlobalLock([in] HGLOBAL hglb);
  446.  
  447.     [
  448.     usesgetlasterror,
  449.     entry("GlobalUnlock"),
  450.     helpstring("Unlocks global memory block"),
  451.     ]
  452.     BOOL    WINAPI GlobalUnlock([in] HGLOBAL hglb);
  453.  
  454.     [
  455.     usesgetlasterror,
  456.     entry("GlobalSize"),
  457.     helpstring("Gets the size of global memory block"),
  458.     ]
  459.     DWORD   WINAPI GlobalSize([in] HGLOBAL hglb);
  460.  
  461.     [
  462.     usesgetlasterror,
  463.     entry("GlobalFlags"),
  464.     helpstring("Gets attribute flags of global memory block"),
  465.     ]
  466.     UINT    WINAPI GlobalFlags([in] HGLOBAL hglb);
  467.  
  468.     [
  469.     usesgetlasterror,
  470.     entry("GlobalCompact"),
  471.     helpstring("Rearranges memory to free requested memory, and returns largest available block size (pass 0 to get size without compacting)"),
  472.     ]
  473.     DWORD   WINAPI GlobalCompact([in] DWORD dwMinFree);
  474.  
  475.     /* Omitted
  476.     DWORD   WINAPI GlobalDosAlloc(DWORD);
  477.     UINT    WINAPI GlobalDosFree(UINT);
  478.     DWORD   WINAPI GlobalHandle(UINT);
  479.  
  480.     void FAR* WINAPI GlobalWire(HGLOBAL);
  481.     BOOL    WINAPI GlobalUnWire(HGLOBAL);
  482.     UINT    WINAPI GlobalPageLock(HGLOBAL);
  483.     UINT    WINAPI GlobalPageUnlock(HGLOBAL);
  484.     void    WINAPI GlobalFix(HGLOBAL);
  485.     void    WINAPI GlobalUnfix(HGLOBAL);
  486.     HGLOBAL WINAPI GlobalLRUNewest(HGLOBAL);
  487.     HGLOBAL WINAPI GlobalLRUOldest(HGLOBAL);
  488.     void    WINAPI GlobalNotify(GNOTIFYPROC);
  489.     HGLOBAL WINAPI LockSegment(UINT);
  490.     void    WINAPI UnlockSegment(UINT);
  491.     UINT    WINAPI AllocSelector(UINT);
  492.     UINT    WINAPI FreeSelector(UINT);
  493.     UINT    WINAPI AllocDStoCSAlias(UINT);
  494.     UINT    WINAPI PrestoChangoSelector(UINT sourceSel, UINT destSel);
  495.     DWORD   WINAPI GetSelectorBase(UINT);
  496.     UINT    WINAPI SetSelectorBase(UINT, DWORD);
  497.     DWORD   WINAPI GetSelectorLimit(UINT);
  498.     UINT    WINAPI SetSelectorLimit(UINT, DWORD);
  499.     void    WINAPI LimitEmsPages(DWORD);
  500.     void    WINAPI ValidateFreeSpaces(void);
  501.  
  502.     // Win32 compatibility macros
  503.     //define DefineHandleTable(w)           ((w),TRUE)
  504.     //define LimitEmsPages(dw)
  505.     //define SetSwapAreaSize(w)             (w)
  506.     //define LockSegment(w)                 GlobalFix((HANDLE)(w))
  507.     //define UnlockSegment(w)               GlobalUnfix((HANDLE)(w))
  508.     //define GetCurrentTime()               GetTickCount()
  509.     //define GlobalLRUNewest( h )   (HANDLE)(h)
  510.     //define GlobalLRUOldest( h )   (HANDLE)(h)
  511.     //define GlobalDiscard( h )     GlobalReAlloc( (h), 0, GMEM_MOVEABLE )
  512.     //define FreeModule(hLibModule) FreeLibrary((hLibModule))
  513.     //define MakeProcInstance(lpProc,hInstance) (lpProc)
  514.     //define FreeProcInstance(lpProc) (lpProc)
  515.     //define Yield()
  516.  
  517.     */
  518.  
  519.     /* All of local memory omitted
  520.     */
  521.  
  522.     /* Virtual memory not implemented
  523.     LPVOID WINAPI VirtualAlloc(LPVOID lpAddress, DWORD dwSize,
  524.                                DWORD flAllocationType, DWORD flProtect);
  525.     BOOL WINAPI VirtualFree(LPVOID lpAddress, DWORD dwSize,
  526.                             DWORD dwFreeType);
  527.     BOOL WINAPI VirtualLock(LPVOID lpAddress, DWORD dwSize);
  528.     BOOL WINAPI VirtualUnlock(LPVOID lpAddress, DWORD dwSize);
  529.     BOOL WINAPI VirtualProtect(LPVOID lpAddress, DWORD dwSize,
  530.                                DWORD flNewProtect, PDWORD lpflOldProtect);
  531.     DWORD WINAPI VirtualQuery(LPCVOID lpAddress,
  532.                               PMEMORY_BASIC_INFORMATION lpBuffer,
  533.                               DWORD dwLength);
  534.     BOOL WINAPI VirtualProtectEx(HANDLE hProcess, LPVOID lpAddress,
  535.                                  DWORD dwSize, DWORD flNewProtect,
  536.                                  PDWORD lpflOldProtect);
  537.     DWORD WINAPI VirtualQueryEx(HANDLE hProcess, LPCVOID lpAddress,
  538.                                 PMEMORY_BASIC_INFORMATION lpBuffer,
  539.                                 DWORD dwLength);
  540.     */
  541.  
  542.     /* Heap memory not implemented
  543.     HANDLE WINAPI HeapCreate(DWORD flOptions, DWORD dwInitialSize,
  544.                              DWORD dwMaximumSize);
  545.     BOOL WINAPI HeapDestroy(HANDLE hHeap);
  546.     LPVOID WINAPI HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwBytes);
  547.     LPVOID WINAPI HeapReAlloc(HANDLE hHeap, DWORD dwFlags,
  548.                               LPVOID lpMem, DWORD dwBytes);
  549.     BOOL WINAPI HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
  550.     DWORD WINAPI HeapSize(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
  551.     BOOL WINAPI HeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem);
  552.     HANDLE WINAPI GetProcessHeap( VOID );
  553.     */
  554.  
  555.     // ****** File I/O **********
  556.  
  557.     /* Omit OpenFile
  558.     typedef struct tagOFSTRUCT
  559.     {
  560.         BYTE cBytes;
  561.         BYTE fFixedDisk;
  562.         UINT nErrCode;
  563.         BYTE reserved[4];
  564.         char szPathName[128];
  565.     } OFSTRUCT;
  566.     typedef OFSTRUCT*       POFSTRUCT;
  567.     typedef OFSTRUCT NEAR* NPOFSTRUCT;
  568.     typedef OFSTRUCT FAR*  LPOFSTRUCT;
  569.  
  570.     HFILE   WINAPI OpenFile(LPCSTR, OFSTRUCT FAR*, UINT);
  571.     */
  572.  
  573.     // OpenFile() Flags
  574.     const DWORD OF_READ              = 0x0000;
  575.     const DWORD OF_WRITE             = 0x0001;
  576.     const DWORD OF_READWRITE         = 0x0002;
  577.     const DWORD OF_SHARE_COMPAT      = 0x0000;
  578.     const DWORD OF_SHARE_EXCLUSIVE   = 0x0010;
  579.     const DWORD OF_SHARE_DENY_WRITE  = 0x0020;
  580.     const DWORD OF_SHARE_DENY_READ   = 0x0030;
  581.     const DWORD OF_SHARE_DENY_NONE   = 0x0040;
  582.     const DWORD OF_PARSE             = 0x0100;
  583.     const DWORD OF_DELETE            = 0x0200;
  584.     const DWORD OF_VERIFY            = 0x0400;
  585.     const DWORD OF_SEARCH            = 0x0400;
  586.     const DWORD OF_CANCEL            = 0x0800;
  587.     const DWORD OF_CREATE            = 0x1000;
  588.     const DWORD OF_PROMPT            = 0x2000;
  589.     const DWORD OF_EXIST             = 0x4000;
  590.     const DWORD OF_REOPEN            = 0x8000;
  591.  
  592.     [
  593.     usesgetlasterror,
  594.     entry("_lopen"),
  595.     helpstring("Opens a file"),
  596.     ]
  597.     HFILE   WINAPI lopen([in] LPCSTR lpszFileName, [in] int fnOpenMode);
  598.  
  599.     [
  600.     usesgetlasterror,
  601.     entry("_lcreat"),
  602.     helpstring("Creates a file"),
  603.     ]
  604.     HFILE   WINAPI lcreat([in] LPCSTR lpszFileName, [in] int fnOpenMode);
  605.  
  606.     [
  607.     usesgetlasterror,
  608.     entry("_lclose"),
  609.     helpstring("Closes a file handle"),
  610.     ]
  611.     HFILE   WINAPI lclose([in] HFILE hf);
  612.  
  613.     [
  614.     usesgetlasterror,
  615.     entry("_lclose"),
  616.     helpstring("Sets the seek position (see SEEK_SET)"),
  617.     ]
  618.     LONG    WINAPI llseek([in] HFILE hf, [in] LONG lOffset, [in] int nOrigin);
  619.  
  620.     [
  621.     usesgetlasterror,
  622.     entry("_lread"),
  623.     helpstring("Reads a buffer from a file"),
  624.     ]
  625.     UINT    WINAPI lread([in] HFILE hf, [out] LPSTR lpBuffer, [in] UINT cbBuffer);
  626.  
  627.     [
  628.     usesgetlasterror,
  629.     entry("_lwrite"),
  630.     helpstring("Writes a buffer to a file"),
  631.     ]
  632.     UINT    WINAPI lwrite([in] HFILE hf, [out] LPSTR lpBuffer, [in] UINT cbBuffer);
  633.  
  634.     /* Omitted
  635.     long    WINAPI _hread([in] HFILE, void _huge*, long);
  636.     long    WINAPI _hwrite(HFILE, const void _huge*, long);
  637.     */
  638.  
  639.     /* Omitted (see Win32)
  640.     // GetTempFileName() Flags
  641.     //define TF_FORCEDRIVE      (BYTE)0x80
  642.  
  643.     int     WINAPI GetTempFileName(BYTE, LPCSTR, UINT, LPSTR);
  644.     BYTE    WINAPI GetTempDrive(char);
  645.  
  646.     UINT    WINAPI GetDriveType(int);
  647.     UINT    WINAPI SetHandleCount(UINT);
  648.     */
  649.  
  650.  
  651.     [
  652.     usesgetlasterror,
  653.     entry("CreateFileA"),
  654.     helpstring("Creates or opens a file, pipe, communications resource, disk device, console, or directory"),
  655.     ]
  656.     HANDLE WINAPI CreateFile([in] LPCSTR lpFileName,
  657.                              [in] DWORD dwDesiredAccess,
  658.                              [in] DWORD dwShareMode,
  659.                              [in] LONG lpSecurityAttributes,
  660.                              [in] DWORD dwCreationDisposition,
  661.                              [in] DWORD dwFlagsAndAttributes,
  662.                              [in] HANDLE hTemplateFile);
  663.  
  664.     [
  665.     usesgetlasterror,
  666.     entry("SetFileAttributesA"),
  667.     helpstring("Sets file attribute bitflags"),
  668.     ]
  669.     BOOL WINAPI SetFileAttributes([in] LPCSTR lpFileName,
  670.                                   [in] DWORD dwFileAttributes);
  671.  
  672.     [
  673.     usesgetlasterror,
  674.     entry("GetFileAttributesA"),
  675.     helpstring("Gets file attribute bitflags"),
  676.     ]
  677.     DWORD WINAPI GetFileAttributes([in] LPCSTR lpFileName);
  678.  
  679.     /* Most File and handle functions not implemented
  680.     DWORD WINAPI GetCompressedFileSizeA(LPCSTR lpFileName,
  681.                                         LPDWORD lpFileSizeHigh);
  682.  
  683.     BOOL WINAPI DeleteFileA(LPCSTR lpFileName);
  684.  
  685.     UINT WINAPI SetHandleCount(UINT uNumber);
  686.  
  687.     BOOL WINAPI LockFile(HANDLE hFile, DWORD dwFileOffsetLow,
  688.                          DWORD dwFileOffsetHigh,
  689.                          DWORD nNumberOfBytesToLockLow,
  690.                          DWORD nNumberOfBytesToLockHigh);
  691.  
  692.     BOOL WINAPI UnlockFile(HANDLE hFile,
  693.                            DWORD dwFileOffsetLow,
  694.                            DWORD dwFileOffsetHigh,
  695.                            DWORD nNumberOfBytesToUnlockLow,
  696.                            DWORD nNumberOfBytesToUnlockHigh);
  697.  
  698.     BOOL WINAPI LockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved,
  699.                            DWORD nNumberOfBytesToLockLow,
  700.                            DWORD nNumberOfBytesToLockHigh,
  701.                            LPOVERLAPPED lpOverlapped);
  702.  
  703.     const DWORD LOCKFILE_FAIL_IMMEDIATELY  = 0x00000001;
  704.     const DWORD LOCKFILE_EXCLUSIVE_LOCK    = 0x00000002;
  705.  
  706.     BOOL WINAPI UnlockFileEx(HANDLE hFile, DWORD dwReserved,
  707.                              DWORD nNumberOfBytesToUnlockLow,
  708.                              DWORD nNumberOfBytesToUnlockHigh,
  709.                              LPOVERLAPPED lpOverlapped);
  710.  
  711.     typedef struct _BY_HANDLE_FILE_INFORMATION {
  712.         DWORD dwFileAttributes;
  713.         FILETIME ftCreationTime;
  714.         FILETIME ftLastAccessTime;
  715.         FILETIME ftLastWriteTime;
  716.         DWORD dwVolumeSerialNumber;
  717.         DWORD nFileSizeHigh;
  718.         DWORD nFileSizeLow;
  719.         DWORD nNumberOfLinks;
  720.         DWORD nFileIndexHigh;
  721.         DWORD nFileIndexLow;
  722.     } BY_HANDLE_FILE_INFORMATION, *PBY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION;
  723.  
  724.     BOOL WINAPI GetFileInformationByHandle(HANDLE hFile,
  725.                         LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
  726.  
  727.     DWORD WINAPI GetFileType(HANDLE hFile);
  728.  
  729.     DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
  730.  
  731.     BOOL WINAPI CopyFileA(LPCSTR lpExistingFileName,
  732.                           LPCSTR lpNewFileName, BOOL bFailIfExists);
  733.  
  734.     BOOL WINAPI MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName);
  735.  
  736.     BOOL WINAPI MoveFileExA(LPCSTR lpExistingFileName,
  737.                             LPCSTR lpNewFileName, DWORD dwFlags);
  738.  
  739.     const DWORD MOVEFILE_REPLACE_EXISTING       = 0x00000001;
  740.     const DWORD MOVEFILE_COPY_ALLOWED           = 0x00000002;
  741.     const DWORD MOVEFILE_DELAY_UNTIL_REBOOT     = 0x00000004;
  742.  
  743.     HANDLE WINAPI GetStdHandle(DWORD nStdHandle);
  744.  
  745.     BOOL WINAPI SetStdHandle(DWORD nStdHandle, HANDLE hHandle);
  746.  
  747.     HFILE WINAPI OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff,
  748.                           UINT uStyle);
  749.  
  750.     BOOL WINAPI WriteFile(HANDLE hFile, LPCVOID lpBuffer,
  751.                           DWORD nNumberOfBytesToWrite,
  752.                           LPDWORD lpNumberOfBytesWritten,
  753.                           LPOVERLAPPED lpOverlapped);
  754.  
  755.     BOOL WINAPI ReadFile(HANDLE hFile, LPVOID lpBuffer,
  756.                          DWORD nNumberOfBytesToRead,
  757.                          LPDWORD lpNumberOfBytesRead,
  758.                          LPOVERLAPPED lpOverlapped);
  759.  
  760.     BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID lpBuffer,
  761.                            DWORD nNumberOfBytesToRead,
  762.                            LPOVERLAPPED lpOverlapped,
  763.                            LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  764.  
  765.     BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID lpBuffer,
  766.                             DWORD nNumberOfBytesToWrite,
  767.                             LPOVERLAPPED lpOverlapped,
  768.                             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
  769.  
  770.     BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
  771.                                 LPVOID lpInBuffer, DWORD nInBufferSize,
  772.                                 LPVOID lpOutBuffer, DWORD nOutBufferSize,
  773.                                 LPDWORD lpBytesReturned,
  774.                                 LPOVERLAPPED lpOverlapped);
  775.  
  776.     BOOL WINAPI SetEndOfFile(HANDLE hFile);
  777.  
  778.     DWORD WINAPI SetFilePointer(HANDLE hFile, LONG lDistanceToMove,
  779.                                 PLONG lpDistanceToMoveHigh,
  780.                                 DWORD dwMoveMethod);
  781.  
  782.     BOOL WINAPI GetFileTime(HANDLE hFile,
  783.                             LPFILETIME lpCreationTime,
  784.                             LPFILETIME lpLastAccessTime,
  785.                             LPFILETIME lpLastWriteTime);
  786.  
  787.     BOOL WINAPI SetFileTime(HANDLE hFile,
  788.                             CONST FILETIME *lpCreationTime,
  789.                             CONST FILETIME *lpLastAccessTime,
  790.                             CONST FILETIME *lpLastWriteTime);
  791.     */
  792.  
  793.     [
  794.     usesgetlasterror,
  795.     entry("CloseHandle"),
  796.     helpstring("Closes an object handle"),
  797.     ]
  798.     BOOL WINAPI CloseHandle([in] HANDLE hObject);
  799.  
  800.     /*
  801.     BOOL WINAPI DuplicateHandle(HANDLE hSourceProcessHandle,
  802.                                 HANDLE hSourceHandle,
  803.                                 HANDLE hTargetProcessHandle,
  804.                                 LPHANDLE lpTargetHandle,
  805.                                 DWORD dwDesiredAccess,
  806.                                 BOOL bInheritHandle, DWORD dwOptions);
  807.  
  808.     BOOL WINAPI GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags);
  809.  
  810.     BOOL WINAPI SetHandleInformation(HANDLE hObject, DWORD dwMask,
  811.                                      DWORD dwFlags);
  812.  
  813.     const DWORD HANDLE_FLAG_INHERIT        = 0x00000001;
  814.     const DWORD HANDLE_FLAG_AUDIT_ON_CLOSE = 0x00000002;
  815.  
  816.     const int HINSTANCE_ERROR = 32;
  817.  
  818.     typedef struct _OFSTRUCT {
  819.         BYTE cBytes;
  820.         BYTE fFixedDisk;
  821.         WORD nErrCode;
  822.         WORD Reserved1;
  823.         WORD Reserved2;
  824.         CHAR szPathName[OFS_MAXPATHNAME];
  825.     } OFSTRUCT, *LPOFSTRUCT, *POFSTRUCT;
  826.  
  827.     */
  828.  
  829.     // ****** Resource Management *******
  830.  
  831.     [
  832.     #ifdef WIN32
  833.     usesgetlasterror,
  834.     entry("FindResourceA"),
  835.     #else
  836.     entry("FindResource"),
  837.     #endif
  838.     helpstring("Finds a resource by its name, type, and module; returns a resource handle"),
  839.     ]
  840.     HRSRC   WINAPI FindResourceStrStr([in] HINSTANCE hInst,
  841.                                       [in] LPCSTR lpszName,
  842.                                       [in] LPCSTR lpszType);
  843.  
  844.     [
  845.     #ifdef WIN32
  846.     usesgetlasterror,
  847.     entry("FindResourceA"),
  848.     #else
  849.     entry("FindResource"),
  850.     #endif
  851.     helpstring("Finds a resource by its name, type, and module; returns a resource handle"),
  852.     ]
  853.     HRSRC   WINAPI FindResourceIdStr([in] HINSTANCE hInst,
  854.                                      [in] DWORD dwName,
  855.                                      [in] LPCSTR lpszType);
  856.  
  857.     [
  858.     #ifdef WIN32
  859.     usesgetlasterror,
  860.     entry("FindResourceA"),
  861.     #else
  862.     entry("FindResource"),
  863.     #endif
  864.     helpstring("Finds a resource by its name, type, and module; returns a resource handle"),
  865.     ]
  866.     HRSRC   WINAPI FindResourceStrId([in] HINSTANCE hInst,
  867.                                      [in] LPCSTR lpszName,
  868.                                      [in] DWORD dwType);
  869.  
  870.     [
  871.     #ifdef WIN32
  872.     usesgetlasterror,
  873.     entry("FindResourceA"),
  874.     #else
  875.     entry("FindResource"),
  876.     #endif
  877.     helpstring("Finds a resource by its name, type, and module; returns a resource handle"),
  878.     ]
  879.     HRSRC   WINAPI FindResourceIdId([in] HINSTANCE hInst,
  880.                                     [in] DWORD dwName,
  881.                                     [in] DWORD dwType);
  882.  
  883.  
  884.     [
  885.     usesgetlasterror,
  886.     entry("LoadResource"),
  887.     helpstring("Loads a resource handle, returning a global memory handle with the resource"),
  888.     ]
  889.     HGLOBAL WINAPI LoadResource([in] HINSTANCE hInst, [in] HRSRC hrsrc);
  890.  
  891.     [
  892.     usesgetlasterror,
  893.     entry("FreeResource"),
  894.     helpstring("Frees a loaded resource passed by the handle received from LoadResource"),
  895.     ]
  896.     BOOL    WINAPI FreeResource([in] HGLOBAL hglbResource);
  897.  
  898.     [
  899.     usesgetlasterror,
  900.     entry("LockResource"),
  901.     helpstring("Locks resource memory block and returns global pointer to it"),
  902.     ]
  903.     LONG WINAPI LockResource([in] HGLOBAL hglbResource);
  904.     // void FAR* WINAPI LockResource([in] HGLOBAL hglbResource);
  905.  
  906.     /* Note: In Win16 UnlockResource is a macro to GlobalUnlock. We have
  907.        to make it an alias. In Win32 UnlockResource is a macro returning
  908.        zero. We can't do that, so we make an alias to GlobalUnlock and
  909.        hope for the best.
  910.     */
  911.  
  912.     [
  913.     usesgetlasterror,
  914.     entry("GlobalUnlock"),
  915.     helpstring("Unlocks resource memory block"),
  916.     ]
  917.     BOOL    WINAPI UnlockResource([in] HGLOBAL hglb);
  918.  
  919.  
  920.     [
  921.     usesgetlasterror,
  922.     entry("SizeofResource"),
  923.     helpstring("Gets the size in bytes of a resource"),
  924.     ]
  925.     DWORD   WINAPI SizeofResource([in] HINSTANCE hInst, [in] HRSRC hrsrc);
  926.  
  927.     /* These two deleted from Win32, so not implemented for Win16
  928.     int     WINAPI AccessResource([in] HINSTANCE hInst, [in] HRSRC hrsrc);
  929.  
  930.     HGLOBAL WINAPI AllocResource([in] HINSTANCE hInst, [in] HRSRC hrsrc, DWORD);
  931.     */
  932.  
  933.     /* Not implemented
  934.     HRSRC WINAPI FindResourceExA(
  935.         HINSTANCE hModule,
  936.         LPCSTR lpType,
  937.         LPCSTR lpName,
  938.         WORD    wLanguage
  939.         );
  940.  
  941.     typedef FARPROC ENUMRESTYPEPROC;
  942.     typedef FARPROC ENUMRESNAMEPROC;
  943.     typedef FARPROC ENUMRESLANGPROC;
  944.  
  945.     BOOL WINAPI EnumResourceTypesA(
  946.         HINSTANCE hModule,
  947.         ENUMRESTYPEPROC lpEnumFunc,
  948.         LONG lParam
  949.         );
  950.  
  951.     BOOL WINAPI EnumResourceNamesA(
  952.         HINSTANCE hModule,
  953.         LPCSTR lpType,
  954.         ENUMRESNAMEPROC lpEnumFunc,
  955.         LONG lParam
  956.         );
  957.  
  958.     BOOL WINAPI EnumResourceLanguagesA(
  959.         HINSTANCE hModule,
  960.         LPCSTR lpType,
  961.         LPCSTR lpName,
  962.         ENUMRESLANGPROC lpEnumFunc,
  963.         LONG lParam
  964.         );
  965.  
  966.     HANDLE WINAPI BeginUpdateResourceA(
  967.         LPCSTR pFileName,
  968.         BOOL bDeleteExistingResources
  969.         );
  970.  
  971.     BOOL WINAPI UpdateResourceA(
  972.         HANDLE      hUpdate,
  973.         LPCSTR     lpType,
  974.         LPCSTR     lpName,
  975.         WORD        wLanguage,
  976.         LPVOID      lpData,
  977.         DWORD       cbData
  978.         );
  979.  
  980.     BOOL WINAPI EndUpdateResourceA(
  981.         HANDLE      hUpdate,
  982.         BOOL        fDiscard
  983.         );
  984.     */
  985.  
  986.     /*
  987.     // OEM Resource Ordinal Numbers
  988.     const long OBM_CLOSE           = 32754;
  989.     const long OBM_UPARROW         = 32753;
  990.     const long OBM_DNARROW         = 32752;
  991.     const long OBM_RGARROW         = 32751;
  992.     const long OBM_LFARROW         = 32750;
  993.     const long OBM_REDUCE          = 32749;
  994.     const long OBM_ZOOM            = 32748;
  995.     const long OBM_RESTORE         = 32747;
  996.     const long OBM_REDUCED         = 32746;
  997.     const long OBM_ZOOMD           = 32745;
  998.     const long OBM_RESTORED        = 32744;
  999.     const long OBM_UPARROWD        = 32743;
  1000.     const long OBM_DNARROWD        = 32742;
  1001.     const long OBM_RGARROWD        = 32741;
  1002.     const long OBM_LFARROWD        = 32740;
  1003.     const long OBM_MNARROW         = 32739;
  1004.     const long OBM_COMBO           = 32738;
  1005.     const long OBM_UPARROWI        = 32737;
  1006.     const long OBM_DNARROWI        = 32736;
  1007.     const long OBM_RGARROWI        = 32735;
  1008.     const long OBM_LFARROWI        = 32734;
  1009.  
  1010.     const long OBM_OLD_CLOSE       = 32767;
  1011.     const long OBM_SIZE            = 32766;
  1012.     const long OBM_OLD_UPARROW     = 32765;
  1013.     const long OBM_OLD_DNARROW     = 32764;
  1014.     const long OBM_OLD_RGARROW     = 32763;
  1015.     const long OBM_OLD_LFARROW     = 32762;
  1016.     const long OBM_BTSIZE          = 32761;
  1017.     const long OBM_CHECK           = 32760;
  1018.     const long OBM_CHECKBOXES      = 32759;
  1019.     const long OBM_BTNCORNERS      = 32758;
  1020.     const long OBM_OLD_REDUCE      = 32757;
  1021.     const long OBM_OLD_ZOOM        = 32756;
  1022.     const long OBM_OLD_RESTORE     = 32755;
  1023.  
  1024.     const long OCR_NORMAL          = 32512;
  1025.     const long OCR_IBEAM           = 32513;
  1026.     const long OCR_WAIT            = 32514;
  1027.     const long OCR_CROSS           = 32515;
  1028.     const long OCR_UP              = 32516;
  1029.     const long OCR_SIZE            = 32640;
  1030.     const long OCR_ICON            = 32641;
  1031.     const long OCR_SIZENWSE        = 32642;
  1032.     const long OCR_SIZENESW        = 32643;
  1033.     const long OCR_SIZEWE          = 32644;
  1034.     const long OCR_SIZENS          = 32645;
  1035.     const long OCR_SIZEALL         = 32646;
  1036.     const long OCR_ICOCUR          = 32647;
  1037.  
  1038.     const long OIC_SAMPLE          = 32512;
  1039.     const long OIC_HAND            = 32513;
  1040.     const long OIC_QUES            = 32514;
  1041.     const long OIC_BANG            = 32515;
  1042.     const long OIC_NOTE            = 32516;
  1043.     */
  1044.  
  1045.     // ****** Atom Management *******
  1046.  
  1047.     /*
  1048.     BOOL    WINAPI InitAtomTable(int);
  1049.     ATOM    WINAPI AddAtom(LPCSTR);
  1050.     ATOM    WINAPI DeleteAtom(ATOM);
  1051.     ATOM    WINAPI FindAtom(LPCSTR);
  1052.     UINT    WINAPI GetAtomName(ATOM, LPSTR, int);
  1053.     ATOM    WINAPI GlobalAddAtom(LPCSTR);
  1054.     ATOM    WINAPI GlobalDeleteAtom(ATOM);
  1055.     ATOM    WINAPI GlobalFindAtom(LPCSTR);
  1056.     UINT    WINAPI GlobalGetAtomName(ATOM, LPSTR, int);
  1057.     HLOCAL  WINAPI GetAtomHandle(ATOM);
  1058.     */
  1059.  
  1060.     // ****** WIN.INI Support ******
  1061.  
  1062.     [
  1063.     #ifdef WIN32
  1064.     usesgetlasterror,
  1065.     entry("GetProfileIntA"),
  1066.     #else
  1067.     entry("GetProfileIntA"),
  1068.     #endif
  1069.     helpstring("Gets an integer value from given entry within given section of WIN.INI (or default if not found)"),
  1070.     ]
  1071.     UINT    WINAPI GetProfileInt([in] LPCSTR lpszSection,
  1072.                                  [in] LPCSTR lpszEntry,
  1073.                                  [in] int iDef);
  1074.  
  1075.     [
  1076.     #ifdef WIN32
  1077.     usesgetlasterror,
  1078.     entry("GetProfileStringA"),
  1079.     #else
  1080.     entry("GetProfileString"),
  1081.     #endif
  1082.     helpstring("Gets a string value from given entry within given section of WIN.INI (or default if not found)"),
  1083.     ]
  1084.     int     WINAPI GetProfileString([in] LPCSTR lpszSection,
  1085.                                     [in] LPCSTR lpszEntry,
  1086.                                     [in] LPCSTR lpszDefault,
  1087.                                     [in, out] LPSTR lpszReturnBuffer,
  1088.                                     [in] int cbReturnBuffer);
  1089.  
  1090.     [
  1091.     #ifdef WIN32
  1092.     usesgetlasterror,
  1093.     entry("WriteProfileStringA"),
  1094.     #else
  1095.     entry("WriteProfileString"),
  1096.     #endif
  1097.     helpstring("Writes given string value to given entry within given section of WIN.INI"),
  1098.     ]
  1099.     BOOL    WINAPI WriteProfileString([in] LPCSTR lpszSection,
  1100.                                       [in] LPCSTR lpszEntry,
  1101.                                       [in] LPCSTR lpszString);
  1102.  
  1103.     [
  1104.     #ifdef WIN32
  1105.     usesgetlasterror,
  1106.     entry("GetPrivateProfileIntA"),
  1107.     #else
  1108.     entry("GetPrivateProfileIntA"),
  1109.     #endif
  1110.     helpstring("Gets an integer value from given entry within given section of INI file (or default if not found)"),
  1111.     ]
  1112.     UINT    WINAPI GetPrivateProfileInt([in] LPCSTR lpszSection,
  1113.                                         [in] LPCSTR lpszEntry,
  1114.                                         [in] int iDef,
  1115.                                         [in] LPCSTR lpszFilename);
  1116.  
  1117.     [
  1118.     #ifdef WIN32
  1119.     usesgetlasterror,
  1120.     entry("GetPrivateProfileStringA"),
  1121.     #else
  1122.     entry("GetPrivateProfileString"),
  1123.     #endif
  1124.     helpstring("Gets a string value from given entry within given section of INI file (or default if not found)"),
  1125.     ]
  1126.     int     WINAPI GetPrivateProfileString([in] LPCSTR lpszSection,
  1127.                                            [in] LPCSTR lpszEntry,
  1128.                                            [in] LPCSTR lpszDefault,
  1129.                                            [in, out] LPSTR lpszReturnBuffer,
  1130.                                            [in] int cbReturnBuffer,
  1131.                                            [in] LPCSTR lpszFilename);
  1132.  
  1133.     [
  1134.     #ifdef WIN32
  1135.     usesgetlasterror,
  1136.     entry("WritePrivateProfileStringA"),
  1137.     #else
  1138.     entry("WritePrivateProfileString"),
  1139.     #endif
  1140.     helpstring("Writes given string value to given entry within given section of INI file"),
  1141.     ]
  1142.     BOOL    WINAPI WritePrivateProfileString([in] LPCSTR lpszSection,
  1143.                                              [in] LPCSTR lpszEntry,
  1144.                                              [in] LPCSTR lpszString,
  1145.                                              [in] LPCSTR lpszFilename);
  1146.  
  1147.     // ******* International & Char Translation Support *******
  1148.  
  1149.     /* Omitted
  1150.     void    WINAPI AnsiToOem(const char _huge*, char _huge*);
  1151.     void    WINAPI OemToAnsi(const char _huge*, char _huge*);
  1152.     void    WINAPI AnsiToOemBuff(LPCSTR, LPSTR, UINT);
  1153.     void    WINAPI OemToAnsiBuff(LPCSTR, LPSTR, UINT);
  1154.     LPSTR   WINAPI AnsiNext(LPCSTR);
  1155.     LPSTR   WINAPI AnsiPrev(LPCSTR, LPCSTR);
  1156.     LPSTR   WINAPI AnsiUpper(LPSTR);
  1157.     LPSTR   WINAPI AnsiLower(LPSTR);
  1158.     UINT    WINAPI AnsiUpperBuff(LPSTR, UINT);
  1159.     UINT    WINAPI AnsiLowerBuff(LPSTR, UINT);
  1160.     BOOL    WINAPI IsCharAlpha(char);
  1161.     BOOL    WINAPI IsCharAlphaNumeric(char);
  1162.     BOOL    WINAPI IsCharUpper(char);
  1163.     BOOL    WINAPI IsCharLower(char);
  1164.     BOOL    WINAPI IsDBCSLeadByte(BYTE);
  1165.     */
  1166.  
  1167.     [
  1168.     #ifdef WIN32
  1169.     usesgetlasterror,
  1170.     entry("lstrcmpA"),
  1171.     #else
  1172.     entry("lstrcmp"),
  1173.     #endif
  1174.     helpstring("Compares two strings (case sensitive) and returns less than zero if first string is less, zero if strings are equal, or greater than zero if first string is greater"),
  1175.     ]
  1176.     int     WINAPI lstrcmp([in] LPSTR lpszString1,
  1177.                            [in] LPSTR lpszString2);
  1178.  
  1179.     [
  1180.     #ifdef WIN32
  1181.     usesgetlasterror,
  1182.     entry("lstrcmpiA"),
  1183.     #else
  1184.     entry("lstrcmpi"),
  1185.     #endif
  1186.     helpstring("Compares two strings (case insensitive) and returns less than zero if first string is less, zero if strings are equal, or greater than zero if first string is greater"),
  1187.     ]
  1188.     int     WINAPI lstrcmpi([in] LPSTR lpszString1,
  1189.                             [in] LPSTR lpszString2);
  1190.  
  1191.     [
  1192.     #ifdef WIN32
  1193.     usesgetlasterror,
  1194.     entry("lstrcpyA"),
  1195.     #else
  1196.     entry("lstrcpy"),
  1197.     #endif
  1198.     helpstring("Copies source string to destination and returns pointer to result"),
  1199.     ]
  1200.     LONG    WINAPI lstrcpy([in] LPSTR lpszDst, [in] LPSTR lpszSrc);
  1201.  
  1202.     [
  1203.     #ifdef WIN32
  1204.     usesgetlasterror,
  1205.     entry("lstrcpyA"),
  1206.     #else
  1207.     entry("lstrcpy"),
  1208.     #endif
  1209.     helpstring("Copies source string to destination and returns pointer to result"),
  1210.     ]
  1211.     LONG    WINAPI lstrcpyFromLp([in] LPSTR lpszDst, [in] LONG lpszSrc);
  1212.  
  1213.     [
  1214.     #ifdef WIN32
  1215.     usesgetlasterror,
  1216.     entry("lstrcpyA"),
  1217.     #else
  1218.     entry("lstrcpy"),
  1219.     #endif
  1220.     helpstring("Copies source string to destination and returns pointer to result"),
  1221.     ]
  1222.     LONG    WINAPI lstrcpyToLp([in] LONG lpszDst, [in] LPSTR lpszSrc);
  1223.  
  1224.     [
  1225.     #ifdef WIN32
  1226.     usesgetlasterror,
  1227.     entry("lstrcatA"),
  1228.     #else
  1229.     entry("lstrcat"),
  1230.     #endif
  1231.     helpstring("Concatenates source string onto destination and returns pointer to result"),
  1232.     ]
  1233.     LONG    WINAPI lstrcat([in] LPSTR lpszDst, [in] LPSTR lpszSrc);
  1234.  
  1235.     [
  1236.     #ifdef WIN32
  1237.     usesgetlasterror,
  1238.     entry("lstrlenA"),
  1239.     #else
  1240.     entry("lstrlen"),
  1241.     #endif
  1242.     helpstring("Returns length of string"),
  1243.     ]
  1244.     int     WINAPI lstrlen([in] LPSTR lpsz);
  1245.  
  1246.     [
  1247.     #ifdef WIN32
  1248.     usesgetlasterror,
  1249.     entry("lstrcpynA"),
  1250.     #else
  1251.     entry("lstrcpyn"),
  1252.     #endif
  1253.     helpstring("Copies given count of characters from source string to destination and returns pointer to result"),
  1254.     ]
  1255.     LONG    WINAPI lstrcpyn([in] LPSTR lpszDst, [in] LPSTR lpszSrc,
  1256.                             [in] int cChars);
  1257.  
  1258.     [
  1259.     #ifdef WIN32
  1260.     usesgetlasterror,
  1261.     entry("RtlMoveMemory"),
  1262.     #else
  1263.     entry("hmemcpy"),
  1264.     #endif
  1265.     helpstring("Copies memory from pointer to byte array"),
  1266.     ]
  1267.     void WINAPI CopyMemoryLpToByte([in, out] BYTE FAR * pvDest,
  1268.                                    [in] DWORD pvSrc, [in] DWORD cbCopy);
  1269.  
  1270.     [
  1271.     #ifdef WIN32
  1272.     usesgetlasterror,
  1273.     entry("RtlMoveMemory"),
  1274.     #else
  1275.     entry("hmemcpy"),
  1276.     #endif
  1277.     helpstring("Copies memory from pointer to byte array"),
  1278.     ]
  1279.     void WINAPI CopyMemoryLpForByte([in] DWORD pvDest,
  1280.                                     [in, out] BYTE FAR * pvSrc,
  1281.                                     [in] DWORD cbCopy);
  1282.  
  1283.     [
  1284.     #ifdef WIN32
  1285.     usesgetlasterror,
  1286.     entry("RtlMoveMemory"),
  1287.     #else
  1288.     entry("hmemcpy"),
  1289.     #endif
  1290.     helpstring("Copies memory from pointer to string"),
  1291.     ]
  1292.     void WINAPI CopyMemoryLpToStr([in] LPSTR lpszDest,
  1293.                                   [in] DWORD pvSrc, [in] DWORD cbCopy);
  1294.  
  1295.     [
  1296.     #ifdef WIN32
  1297.     usesgetlasterror,
  1298.     entry("RtlMoveMemory"),
  1299.     #else
  1300.     entry("hmemcpy"),
  1301.     #endif
  1302.     helpstring("Copies memory from pointer to pointer"),
  1303.     ]
  1304.     void WINAPI CopyMemoryLpToLp([in] DWORD pvDest,
  1305.                                  [in] DWORD pvSrc, [in] DWORD cbCopy);
  1306.  
  1307.     /* Keyboard Driver Functions omitted
  1308.     */
  1309.  
  1310. }
  1311.  
  1312.  
  1313. [
  1314. uuid(54674043-3A82-101B-8181-00AA003743D3),
  1315. helpstring("Windows Kernel Constants"),
  1316. #ifdef WIN32
  1317. dllname("KERNEL32.DLL")
  1318. #else
  1319. dllname("KRNL386.EXE")
  1320. #endif
  1321. ]
  1322. module KernelConst {
  1323.  
  1324.     [ helpstring("GetFreeSystemResources: Total Resources") ]
  1325.     const int GFSR_SYSTEMRESOURCES = 0;
  1326.     [ helpstring("GetFreeSystemResources: GDI Resources") ]
  1327.     const int GFSR_GDIRESOURCES = 1;
  1328.     [ helpstring("GetFreeSystemResources: USER Resources") ]
  1329.     const int GFSR_USERRESOURCES = 2;
  1330.  
  1331.     [ helpstring("GetWinFlags: Protected mode") ]
  1332.     const UINT WF_PMODE     = 0x0001;
  1333.     [ helpstring("GetWinFlags: 80286 CPU") ]
  1334.     const UINT WF_CPU286        = 0x0002;
  1335.     [ helpstring("GetWinFlags: 80386 CPU") ]
  1336.     const UINT WF_CPU386        = 0x0004;
  1337.     [ helpstring("GetWinFlags: 80486 CPU or higher") ]
  1338.     const UINT WF_CPU486        = 0x0008;
  1339.     [ helpstring("GetWinFlags: Standard mode") ]
  1340.     const UINT WF_STANDARD  = 0x0010;
  1341.     [ helpstring("GetWinFlags: Enhanced mode") ]
  1342.     const UINT WF_ENHANCED  = 0x0020;
  1343.     [ helpstring("GetWinFlags: Coprocessor") ]
  1344.     const UINT WF_80x87     = 0x0400;
  1345.     [ helpstring("GetWinFlags: Paging") ]
  1346.     const UINT WF_PAGING        = 0x0800;
  1347.     [ helpstring("GetWinFlags: Windows NT") ]
  1348.     const long WF_WINNT     = 0x4000;
  1349.     [ helpstring("GetWinFlags: OS/2 emulation") ]
  1350.     const long WF_WLO       = 0x8000;
  1351.  
  1352.     // Global Memory Flags
  1353.  
  1354.     [ helpstring("Fixed memory flag for GlobalAlloc") ]
  1355.     const UINT GMEM_FIXED       = 0x0000;
  1356.     [ helpstring("Moveable memory flag for GlobalAlloc") ]
  1357.     const UINT GMEM_MOVEABLE        = 0x0002;
  1358.     [ helpstring("No compact memory flag for GlobalAlloc") ]
  1359.     const UINT GMEM_NOCOMPACT   = 0x0010;
  1360.     [ helpstring("No discard memory flag for GlobalAlloc") ]
  1361.     const UINT GMEM_NODISCARD   = 0x0020;
  1362.     [ helpstring("Zero init memory flag for GlobalAlloc") ]
  1363.     const UINT GMEM_ZEROINIT        = 0x0040;
  1364.     [ helpstring("Modify memory flag for GlobalAlloc") ]
  1365.     const UINT GMEM_MODIFY      = 0x0080;
  1366.     [ helpstring("Discardable memory flag for GlobalAlloc and GlobalFlags") ]
  1367.     const UINT GMEM_DISCARDABLE = 0x0100;
  1368.     [ helpstring("Shared memory flag for GlobalAlloc") ]
  1369.     const UINT GMEM_SHARE       = 0x2000;
  1370.     [ helpstring("Fixed memory flag for GlobalAlloc") ]
  1371.     const UINT GMEM_NOTIFY      = 0x4000;
  1372.     [ helpstring("Notification memory flag for GlobalAlloc") ]
  1373.     const UINT GMEM_LOWER       = 0x1000;
  1374.     [ helpstring("Fixed and zero init memory flag for GlobalAlloc") ]
  1375.     const UINT GPTR             = 0x0040;
  1376.     [ helpstring("Discarded flag from GlobalFlags") ]
  1377.     const UINT GMEM_DISCARDED   = 0x4000;
  1378.     [ helpstring("Lock count flag from GlobalFlags") ]
  1379.     const UINT GMEM_LOCKCOUNT   = 0x00FF;
  1380.  
  1381.     /*
  1382.     const UINT GMEM_NOT_BANKED    = 0x1000;
  1383.     const UINT GMEM_DDESHARE      = 0x2000;
  1384.     const UINT GMEM_VALID_FLAGS   = 0x7F72;
  1385.     const UINT GMEM_INVALID_HANDLE = 0x8000;
  1386.     */
  1387.  
  1388.     // _lopen() flags
  1389.     [ helpstring("Read flag for lopen") ]
  1390.     const int READ          = 0;
  1391.     [ helpstring("Write flag for lopen") ]
  1392.     const int WRITE         = 1;
  1393.     [ helpstring("Read/write flag for lopen") ]
  1394.     const int READ_WRITE    = 2;
  1395.  
  1396.     // _llseek origin values
  1397.     [ helpstring("Move seek position from start of file (llseek)") ]
  1398.     const int SEEK_SET  = 0;
  1399.     [ helpstring("Move seek position from current position (llseek)") ]
  1400.     const int SEEK_CUR  = 1;
  1401.     [ helpstring("Move seek position from end of file (llseek)") ]
  1402.     const int SEEK_END  = 2;
  1403.  
  1404.     // Predefined Resource Types
  1405.     [ helpstring("FindResource: Resource type") ]
  1406.     const long RT_CURSOR        = 1;
  1407.     [ helpstring("FindResource: Resource type") ]
  1408.     const long RT_BITMAP        = 2;
  1409.     [ helpstring("FindResource: Resource type") ]
  1410.     const long RT_ICON          = 3;
  1411.     [ helpstring("FindResource: Resource type") ]
  1412.     const long RT_MENU          = 4;
  1413.     [ helpstring("FindResource: Resource type") ]
  1414.     const long RT_DIALOG        = 5;
  1415.     [ helpstring("FindResource: Resource type") ]
  1416.     const long RT_STRING        = 6;
  1417.     [ helpstring("FindResource: Resource type") ]
  1418.     const long RT_FONTDIR       = 7;
  1419.     [ helpstring("FindResource: Resource type") ]
  1420.     const long RT_FONT          = 8;
  1421.     [ helpstring("FindResource: Resource type") ]
  1422.     const long RT_ACCELERATOR   = 9;
  1423.     [ helpstring("FindResource: Resource type") ]
  1424.     const long RT_RCDATA        = 10;
  1425.  
  1426.     [ helpstring("FindResource: Resource type") ]
  1427.     const long RT_GROUP_CURSOR  = 12;
  1428.     [ helpstring("FindResource: Resource type") ]
  1429.     const long RT_GROUP_ICON    = 14;
  1430.  
  1431.     // Errors
  1432.     [ helpstring("WNet: Function succeeded") ]
  1433.     const UINT WN_SUCCESS           = 0x0000;
  1434.     [ helpstring("WNet: Function not supported") ]
  1435.     const UINT WN_NOT_SUPPORTED     = 0x0001;
  1436.     [ helpstring("WNet: Network error") ]
  1437.     const UINT WN_NET_ERROR         = 0x0002;
  1438.     [ helpstring("WNet: Buffer too small") ]
  1439.     const UINT WN_MORE_DATA         = 0x0003;
  1440.     [ helpstring("WNet: A pointer value was invalid") ]
  1441.     const UINT WN_BAD_POINTER       = 0x0004;
  1442.     [ helpstring("WNet: Local name invalid") ]
  1443.     const UINT WN_BAD_VALUE         = 0x0005;
  1444.     [ helpstring("WNet: Invalid password") ]
  1445.     const UINT WN_BAD_PASSWORD      = 0x0006;
  1446.     [ helpstring("WNet: A security violation occurred") ]
  1447.     const UINT WN_ACCESS_DENIED     = 0x0007;
  1448.     [ helpstring("WNet: The requested resource is in use") ]
  1449.     const UINT WN_FUNCTION_BUSY     = 0x0008;
  1450.     [ helpstring("WNet: Unexpected error") ]
  1451.     const UINT WN_WINDOWS_ERROR     = 0x0009;
  1452.     [ helpstring("WNet: Invalid user") ]
  1453.     const UINT WN_BAD_USER          = 0x000A;
  1454.     [ helpstring("WNet: System out of memory") ]
  1455.     const UINT WN_OUT_OF_MEMORY     = 0x000B;
  1456.     [ helpstring("WNet: Canceled by user") ]
  1457.     const UINT WN_CANCEL                = 0x000C;
  1458.     [ helpstring("WNet: Continued by user") ]
  1459.     const UINT WN_CONTINUE          = 0x000D;
  1460.  
  1461.     // Connection errors
  1462.     [ helpstring("WNet: Network connection does not exist") ]
  1463.     const UINT WN_NOT_CONNECTED     = 0x0030;
  1464.     [ helpstring("WNet: Files are open, but force not specified") ]
  1465.     const UINT WN_OPEN_FILES            = 0x0031;
  1466.     [ helpstring("WNet: Remote name invalid or already connected") ]
  1467.     const UINT WN_BAD_NETNAME       = 0x0032;
  1468.     [ helpstring("WNet: Local name invalid") ]
  1469.     const UINT WN_BAD_LOCALNAME     = 0x0033;
  1470.     [ helpstring("WNet: Local device already in use") ]
  1471.     const UINT WN_ALREADY_CONNECTED = 0x0034;
  1472.     [ helpstring("WNet: Device not functioning") ]
  1473.     const UINT WN_DEVICE_ERROR      = 0x0035;
  1474.     [ helpstring("WNet: Device not currently connected, but is a remembered connection") ]
  1475.     const UINT WN_CONNECTION_CLOSED = 0x0036;
  1476.  
  1477.     [ helpstring("GetBinaryType: Win32 application") ]
  1478.     const UINT SCS_32BIT_BINARY  = 0;
  1479.     [ helpstring("GetBinaryType: MS-DOS application") ]
  1480.     const UINT SCS_DOS_BINARY    = 1;
  1481.     [ helpstring("GetBinaryType: 16-bit Windows application") ]
  1482.     const UINT SCS_WOW_BINARY    = 2;
  1483.     [ helpstring("GetBinaryType: PIF file") ]
  1484.     const UINT SCS_PIF_BINARY    = 3;
  1485.     [ helpstring("GetBinaryType: Posix application") ]
  1486.     const UINT SCS_POSIX_BINARY  = 4;
  1487.     [ helpstring("GetBinaryType: 16-bit OS/2 application") ]
  1488.     const UINT SCS_OS216_BINARY  = 5;
  1489.  
  1490. }
  1491.